package com.project.personal_blog.garbage_classification_management_system.Controller;

import com.project.personal_blog.garbage_classification_management_system.pojo.Code;
import com.project.personal_blog.garbage_classification_management_system.pojo.Result;
import com.project.personal_blog.garbage_classification_management_system.pojo.User;
import com.project.personal_blog.garbage_classification_management_system.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;


    @GetMapping("/select/{name}")
    public ResponseEntity<Result> selectByUsername(@PathVariable String name) {
        // 根据用户名查询用户
        try {
            User user = userService.selectByUsername(name);
            Result result;
            if (user == null) {
                // 如果用户列表为空，返回一个错误或空的结果
                result = new Result("没有找到用户", Code.SELECT_FAIL);
            } else {
                // 如果用户列表不为空，返回成功的结果，并包含用户列表数据
                result = new Result("查找用户成功", Code.SELECT_SUCCESS, user);
            }
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            // 捕获异常，并抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    @GetMapping("/select/{id}")
    public ResponseEntity<Result> selectById(@PathVariable Integer id) {
        // 根据id查找用户
        try {
            User user = userService.selectById(id);
            Result result;
            if (user == null) {
                // 如果用户列表为空，返回一个错误或空的结果
                result = new Result("没有找到用户", Code.SELECT_FAIL);
            } else {
                // 如果用户列表不为空，返回成功的结果，并包含用户列表数据
                result = new Result("查找用户成功", Code.SELECT_SUCCESS, user);
            }
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            // 捕获异常，并抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    @GetMapping("/select/{phoneNumber}")
    public ResponseEntity<Result> selectByPhoneNumber(@PathVariable String phoneNumber) {
        try {
            // 根据电话号码查询用户
            User user = userService.selectByPhoneNumber(phoneNumber);
            Result result;
            if (user == null) {
                // 如果用户列表为空，返回一个错误或空的结果
                result = new Result("没有找到用户", Code.SELECT_FAIL);
            } else {
                // 如果用户列表不为空，返回成功的结果，并包含用户列表数据
                result = new Result("查找用户成功", Code.SELECT_SUCCESS, user);
            }
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            // 捕获异常，并抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    @GetMapping("/select/{email}")
    public ResponseEntity<Result> selectByEmail(@PathVariable String email) {
        // 根据邮箱查询用户
        try {
            User user = userService.selectByEmail(email);
            Result result;
            if (user == null) {
                // 如果用户列表为空，返回一个错误或空的结果
                result = new Result("没有找到用户", Code.SELECT_FAIL);
            } else {
                // 如果用户列表不为空，返回成功的结果，并包含用户列表数据
                result = new Result("查找用户成功", Code.SELECT_SUCCESS, user);
            }
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            // 捕获异常，并抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    // 获取指定页码和每页显示记录数
    @GetMapping("/{pageNumber}/{pageSize}")
    public ResponseEntity<Result> pageUser(@PathVariable Integer pageNumber, @PathVariable Integer pageSize) {
        // 调用用户服务分页查询用户
        try {
            boolean result = userService.pageUser(pageNumber, pageSize);
            Result result1;
            // 如果查询失败
            if (!result) {
                // 返回用户不存在,无法分页查询
                result1 = new Result("用户不存在,无法分页查询", Code.PAGESELECT_FAIL, false);
            } else {
                // 返回分页查询成功
                result1 = new Result("分页查询成功", Code.PAGESELECT_SUCCESS);
            }
            // 返回查询结果
            return ResponseEntity.ok(result1);
        } catch (Exception e) {
            // 抛出运行异常
            throw new RuntimeException(e);
        }
    }

    // 根据id1和id2的值进行排序
    @PostMapping("/{id1}/{id2}")
    public ResponseEntity<Result> sortById(@PathVariable Integer id1, @PathVariable Integer id2) {
        try {
            // 调用userService的sortById方法，根据id1和id2的值进行排序
            boolean result = userService.sortById(id1, id2);
            // 创建一个Result对象，用于返回结果
            Result result1;
            // 如果排序失败，返回一个错误信息
            if (!result) {
                result1 = new Result("用户不存在,无法进行排序", Code.SORT_FAIL, false);
            } else {
                // 如果排序成功，返回一个成功信息
                result1 = new Result("排序成功", Code.SORT_SUCCESS);
            }
            // 返回排序结果
            return ResponseEntity.ok(result1);
        } catch (Exception e) {
            // 抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    @PostMapping("/{name1}/{name2}")
    public ResponseEntity<Result> sortByName(@PathVariable String name1, @PathVariable String name2) {
        // 根据name1和name2对用户进行排序
        try {
            boolean result = userService.sortByName(name1, name2);
            Result result1;
            // 如果排序失败，返回用户不存在,无法进行排序
            if (!result) {
                result1 = new Result("用户不存在,无法进行排序", Code.SORT_FAIL, false);
            } else {
                // 如果排序成功，返回排序成功
                result1 = new Result("排序成功", Code.SORT_SUCCESS);
            }
            // 返回排序结果
            return ResponseEntity.ok(result1);
        } catch (Exception e) {
            // 抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    @PostMapping("/{phoneNumber1}/{phoneNumber2}")
    public ResponseEntity<Result> sortByPhoneNumber(@PathVariable String phoneNumber1, @PathVariable String phoneNumber2) {
        // 根据手机号1和手机号2进行排序
        try {
            boolean result = userService.sortByPhoneNumber(phoneNumber1, phoneNumber2);
            Result result1;
            // 如果排序失败，返回用户不存在,无法进行排序
            if (!result) {
                result1 = new Result("用户不存在,无法进行排序", Code.SORT_FAIL, false);
            } else {
                // 如果排序成功，返回排序成功
                result1 = new Result("排序成功", Code.SORT_SUCCESS);
            }
            // 返回排序结果
            return ResponseEntity.ok(result1);
        } catch (Exception e) {
            // 抛出运行时异常
            throw new RuntimeException(e);
        }
    }

    @PostMapping("/{email1}/{email2}")
    public ResponseEntity<Result> sortByEmail(@PathVariable String email1, @PathVariable String email2) {
        // 根据email1和email2对用户进行排序
        try {
            boolean result = userService.sortByEmail(email1, email2);
            Result result1;
            // 如果排序失败，返回用户不存在,无法进行排序
            if (!result) {
                result1 = new Result("用户不存在,无法进行排序", Code.SORT_FAIL, false);
            } else {
                // 如果排序成功，返回排序成功
                result1 = new Result("排序成功", Code.SORT_SUCCESS);
            }
            // 返回排序结果
            return ResponseEntity.ok(result1);
        } catch (Exception e) {
            // 抛出运行时异常
            throw new RuntimeException(e);
        }
    }
}
